"use strict";

var uk = require('./def.js');

/**默认角色属性 */
var defprops = {hp:0,mp:0,def:0,atk:0,exp:0,lv:1};
/**不需要更新的属性 */
var noresetprops = {exp:1,lv:1};

/** 角色模板 */
uk.t_roles = {};

/** 玩家状态 */
uk.player_status = {
    NONE:0,
    READY:1,
    PLAYING:2,
    FINISH:3,
    OFFLINE:0x10
}

/** 计算角色扩展属性对原始属性的加成 */
function calc_exprop_add_prop_val(props,exprops){
    for(var k in exprops){
        switch(k)
        {
            case '体质':props.hp += Math.floor(exprops[k]/2);break;
            case '精神':props.mp += Math.floor(exprops[k]/3);break;
            case '力量':props.atk += Math.ceil(exprops[k]/5);break;
        }
    }
}

/** 定义角色模板 */
uk.def_role=function(id,name,ai,lvinfo){
    if(lvinfo[0] != null){
        console.error(name," lvinfo 第一项必须为null");
        return null;
    }
    var r = {
        id:id,
        name:name,
        ai:ai,
        lvinfo:lvinfo
    };
    uk.t_roles[id] = r;
    return r;
}

/** 定义怪物模板 */
uk.def_monster=function(id,name,ai,lvinfo){
    if(lvinfo[0] != null){
        console.error(name," lvinfo 第一项必须为null");
        return null;
    }
    var r = {
        id:id,
        name:name,
        ai:ai,
        lvinfo:lvinfo
    };
    uk.t_roles[id] = r;
    return r;
}

/** 获取属性名字 */
uk.get_prop_name=function(p){
    switch(p)
    {
        case 'hp':return '生命值';
        case 'mp':return '魔法值';
        case 'def':return '物理防御';
        case 'mdef':return '魔法防御';
        case 'atk':return '攻击力';
        case 'magic':return '魔法力';
        case 'exp':return '经验值';
        case 'lv':return '等级';
        case 'gold':return '金币';
    }
}

/**属性变更器 */
uk.create_changer=function(){
    var ret = {
        __changed:0,
        __props:{},
        __buffadd:[],
        __buffdel:[],
        __equipadd:[],
        __equipdel:[],
        __value:null
    };
    ret.changed=function(){
        return this.__changed != 0;
    }
    ret.change_prop=function(k,v){
        if(!this.__props.hasOwnProperty(k))
            this.__props[k] = v;
        else
            this.__props[k] += v;
        this.__changed |= 0x01;
    }
    ret.set_props=function(props,recover){
        if(!recover)
            this.__props = {};
        for(var k in props)
            this.__props[k] = props[k];
        /**更改属性，覆盖模式 */
        this.__changed |= 0x01|0x8000;
    }
    ret.add_buff=function(b){
        this.__buffadd.push(b);
        this.__changed |= 0x02;
    }
    ret.del_buff=function(b){
        this.__buffdel.push(b);
        this.__changed |= 0x04;
    }
    ret.add_equip=function(b){
        this.__equipadd.push(b);
        this.__changed |= 0x08;
    }
    ret.del_equip=function(b){
        this.__equipdel.push(b);
        this.__changed |= 0x10;
    }
    ret.value=function(){
        if(this.__changed == 0)
            return null;
        if(this.__value != null)
            return this.__value;
        var r = {};
        if(this.__changed&0x01)
            r.props = this.__props;
        if(this.__changed&0x02)
            r.buffadd = this.__buffadd;
        if(this.__changed&0x04)
            r.buffdel = this.__buffdel;
        if(this.__changed&0x08)
            r.equipadd = this.__equipadd;
        if(this.__changed&0x10)
            r.equipdel = this.__equipdel;
        r.mask = this.__changed;
        return this.__value=r;
    }
    ret.reset=function(){
        this.__changed=0;
        this.__props ={};
        this.__buffadd=[];
        this.__buffdel=[];
        this.__equipadd=[];
        this.__equipdel=[];
        this.__value=null;
    }
    return ret;
}

/** 创建角色 */
uk.create_role = function(roleid,noupdate,level){
    if(!uk.t_roles.hasOwnProperty(roleid)){
        console.log('create role failed,no template with id:'+roleid);
        return null;
    }
    var tr = uk.t_roles[roleid];
    var r = {
        id:0,
        template:tr,
        name:tr.name,
        /** 所在房间 */
        room:null,
        /** 所属用户 */
        user:null,
        /** 队伍分组，通常npc一组，玩家一组 */
        team:0,
        /** 房间中的座位 */
        seat:0,
        /** 状态 */
        status:uk.player_status.NONE,
        /** 拥有的牌 */
        cards:{},
        /** buff列表 */
        buffs:[],
        /** 属性 */
        props:{},
        /** 装备 */
        equips:{},
        /** 当前所在关卡信息，是个多选项 */
        stations:{},
        /**任务数据 */
        tasks:{},
        /** 牌信息 */
        handcards:[],    /** 手牌 */
        outcards:[],     /** 打出的牌，已经死掉的 */
        dealcards:[]     /** 发牌，每个玩家自己的牌是不一样的 */
    }
    r.on_action=function(act,actstatus,src,param,changed){
        var result=true;
        for(var i = 0;i < this.buffs.length;++i){
            var b = this.buffs[i];
            /** 模板回合数小于等于0，表示不限制回合 */
            if(b.alive)
                result = b.template.on_action(b,act,actstatus,b.giver,this,param,changed)?true:result;
        }
        if(act == uk.events.ROUND_BEGIN && actstatus == uk.event_status.NOW){
            for(var i = 0;i < this.buffs.length;++i){
                var b = this.buffs[i];
                if(b.template.round>0)
                    b.round --;
            }
        }else if(act == uk.events.ROUND_END){
            for(var i = 0;i < this.buffs.length;){
                var b = this.buffs[i];
                if(b.template.round>0 && actstatus == uk.event_status.NOW){
                    b.alive = --b.round>0;
                }else if(!b.alive && actstatus == uk.event_status.AFTER){
                    uk.actions.del_buff_byindex(this,this,i,changed);
                    continue;  
                }
                ++i;
            }
        }
        return result;
    }
    /** 根据等级动态计算属性 */
    r.reset=function(lv){
        var tr = r.template;
        lv = lv ? lv:this.props.lv;
        lv = lv ? lv : 1;
        var lvinfo = tr.lvinfo[lv];
        /** 先用默认的 */
        for(var k in defprops){
            if(noresetprops.hasOwnProperty(k) && this.props.hasOwnProperty(k))
                continue;
            this.props[k] = defprops[k];
        }
        /** 然后覆盖定义的属性 */
        for(var k in lvinfo.props){
            if(noresetprops.hasOwnProperty(k) && this.props.hasOwnProperty(k))
                continue;
            this.props[k] = lvinfo.props[k];
        }
        if(this.ownedcards){/**自身拥有卡牌，则不从模版创建 */
            this.cards = this.ownedcards;
        }else{
            /** 卡牌也需要创建，避免逻辑中更改了模板的值，这里通常只有npc才会有牌 */
            this.cards = {};
            for(var k in lvinfo.cards){
                this.cards[k] = lvinfo.cards[k];
            }
        }
        /**清理掉buff */
        this.buffs = [];
        /**装备 */
        if(lvinfo.hasOwnProperty('equips')){
            for(var k in lvinfo.equips){
                this.equips[k] = lvinfo.equips[k];
                /**这里需要加入装备的buff特效 */
            }
        }
        if(lvinfo.hasOwnProperty('dropitem')){
            this.dropitem = lvinfo.dropitem;
        }
        /**触发属性更改，以得到最新的数据 */
        this.on_action(uk.events.ROLEBUILD,uk.event_status.BEFORE,this,null,null);
        this.on_action(uk.events.ROLEBUILD,uk.event_status.NOW,this,null,null);
        this.on_action(uk.events.ROLEBUILD,uk.event_status.AFTER,this,null,null);        
        /** 扩展属性计算，放在角色创建之后，装备增加buff是在build的时候 */
        if(lvinfo.hasOwnProperty('exprops')){
            calc_exprop_add_prop_val(this.props,lvinfo.exprops);
        }
        if(this.hasOwnProperty('exprops')){
            calc_exprop_add_prop_val(this.props,this.exprops);
        }
        this.props.maxexp = lvinfo.exp;
        this.props.maxhp = lvinfo.props.hp;
        this.props.maxmp = lvinfo.props.mp;
        /** 怪物的队伍都是-1 */
        if(uk.ismonster(this))
            this.team = -1;
    }
    /** 更新属性 */
    if(!noupdate)
        r.reset(level);
    return r;
}